package com.gjzhao.fmmall.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import com.github.pagehelper.PageInfo;
import com.github.wxpay.sdk.WXPay;
import com.gjzhao.fmmall.config.PayConfig;
import com.gjzhao.fmmall.constant.Constants;
import com.gjzhao.fmmall.dao.OrderItemMapper;
import com.gjzhao.fmmall.dao.OrdersMapper;
import com.gjzhao.fmmall.dao.ProductSkuMapper;
import com.gjzhao.fmmall.dao.ShoppingCartMapper;
import com.gjzhao.fmmall.entity.OrderItem;
import com.gjzhao.fmmall.entity.Orders;
import com.gjzhao.fmmall.entity.ProductSku;
import com.gjzhao.fmmall.service.OrdersService;
import com.gjzhao.fmmall.vo.OrdersVO;
import com.gjzhao.fmmall.vo.PageHelper;
import com.gjzhao.fmmall.vo.ResponseResultVO;
import com.gjzhao.fmmall.vo.RespCode;
import com.gjzhao.fmmall.vo.ShoppingCartVO;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

/**
 * @Description: 订单 ServiceImpl
 * @Author: gjzhao
 * @Date Created in 2022-01-09 5:43 下午
 */
@Service
public class OrdersServiceImpl implements OrdersService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private ShoppingCartMapper shoppingCartMapper;
    @Autowired
    private OrdersMapper ordersMapper;
    @Autowired
    private OrderItemMapper orderItemMapper;
    @Autowired
    private ProductSkuMapper productSkuMapper;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private DefaultRedisScript defaultRedisScript;
    @Autowired
    private RedissonClient redissonClient;


    /**
     * 订单处理(自定义实现分布式锁)
     *
     * @param cartIds
     * @param order
     * @return
     */
    @Override
    @Transactional //整个为一个事物操作
    public ResponseResultVO addOrder(String cartIds, Orders order) throws Exception {

        //参数校验
        if (StrUtil.isEmpty(cartIds) || ObjectUtil.isNull(order)) {
            return new ResponseResultVO(RespCode.FAILED.getCode(), "购物车id或需要添加的订单信息不能为空", null);
        }


        String[] cidArray = cartIds.split(",");
        List<Integer> cidList = new ArrayList<>();
        for (int i = 0; i < cidArray.length; i++) {
            cidList.add(Integer.parseInt(cidArray[i]));
        }
        //根据购物车ids查询所有商品信息
        List<ShoppingCartVO> cartVOList = shoppingCartMapper.listShoppingCartByCartIds(cidList);
        logger.debug("-------需要购买购物车商品信息1:{}------", cartVOList);


        logger.info("---在多台应用服务器场景下，为防止出现超卖现象，使用redis作分布式锁，开始上锁----");
        boolean isLock = true;
        String[] skuIds = new String[cartVOList.size()];
        Map<String, String> map = new HashMap<String, String>(); //存一份标识记录，在释放锁时使用
        //一个购物车中可能存在多个商品，需要以每个商品的skuId为key向redis中添加一条记录
        for (int i = 0; i < cartVOList.size(); i++) {
            String skuId = cartVOList.get(i).getSkuId();
            // 商品1：skuId1 -> orderRecord
            // 商品2：skuId2 -> orderRecord
            //为防止业务还未操作完成，锁自动过期，导致释放的是其他线程的锁，添加一个标识
            String uuid = UUID.fastUUID().toString();
            Boolean ifAbsent = stringRedisTemplate.boundValueOps(skuId).setIfAbsent(uuid, 10, TimeUnit.SECONDS);
            //只要商品上锁成功，就记录下来
            if (ifAbsent) {
                skuIds[i] = skuId;
                map.put(skuId, uuid);
            }
            isLock = isLock && ifAbsent; //只要有一件商品没有加锁成功，就表示该笔订单没有加锁成功，需要记录已经上锁的商品
        }

        if (isLock) {
            try {

                logger.info("----当前订单所有商品上锁成功，开始一系列业务操作-------");

                logger.info("----不能马上进行校验库存操作，高并发场景下，可能在查询购物车信息之后，商品加锁之前，其他用户已经修改了库存，此时需要重新查询库存信息-------");

                cartVOList = shoppingCartMapper.listShoppingCartByCartIds(cidList);

                //1.校验库存
                logger.info("-------------开始校验库存---------");

                List<String> productNameList = new ArrayList<>();
                boolean isEnoughStock = true;
                for (ShoppingCartVO cartVO : cartVOList) {
                    if (cartVO.getCartNum() > cartVO.getSkuStock()) {
                        isEnoughStock = false;
                    }
                    productNameList.add(cartVO.getProductName());
                }
                //获取所有商品名称，以,分割拼接成字符串
                String productNames = String.join(",", productNameList);

                if (isEnoughStock) {
                    logger.info("-------------库存校验完成,库存足够。开始生成订单信息---------");

                    //2.保存订单
                    //生成订单编号(简化版uuid)
                    String orderId = IdUtil.simpleUUID();

                    order.setOrderId(orderId);
                    order.setUntitled(productNames);
                    order.setStatus(Constants.OrderStats.NOT_PAYMENT.getValue());
                    order.setCreateTime(new Date());
                    int i = ordersMapper.insert(order);

                    logger.info("-------------订单保存完成。开始生成商品快照---------");

                    //3.生成商品快照
                    for (ShoppingCartVO cv : cartVOList) {
                        String itemId = System.currentTimeMillis() + "" + RandomUtil.randomInt(99999);
                        OrderItem orderItem =
                            new OrderItem(itemId, orderId, cv.getProductId(), cv.getProductName(), cv.getProductImg(), cv.getSkuId(), cv.getSkuName(), cv.getProductPrice(), cv.getCartNum(), new BigDecimal(cv.getSellPrice() * cv.getCartNum()), DateUtil.parse(cv.getCartTime(), "yyyy-MM-dd"),
                                          new Date(),
                                          Constants.CommentStatus.NOT_COMMENT.getValue());

                        int j = orderItemMapper.insert(orderItem);
                        //TODO 增加商品销量，添加时机需要放在用户签收货物后，该笔订单为已完成状态，再增加销量
                    }

                    logger.info("-------------商品快照生成完成。开始扣减库存---------");

                    //4.扣减库存
                    for (ShoppingCartVO sc : cartVOList) {

                        //计算新库存
                        String skuId = sc.getSkuId();
                        int newStock = sc.getSkuStock() - sc.getCartNum();

                        //使用tkmapper提供的方法进行更新:tk会根据传入的id进行部分字段更新
                        ProductSku productSku = new ProductSku();
                        productSku.setSkuId(skuId);
                        productSku.setStock(newStock);

                        int k = productSkuMapper.updateByPrimaryKeySelective(productSku);
                    }
                    logger.info("-------------扣减库存完成。开始删除购物车信息---------");

                    //5.删除购物车：当购物车中的记录购买成功之后，购物车中对应做删除操作
                    for (Integer integer : cidList) {
                        //根据id删除购物车信息
                        shoppingCartMapper.deleteByPrimaryKey(integer);
                    }
                    logger.info("-------------删除购物车信息完成。---------");

                    logger.info("-------------订单处理完成。生成订单编号：[" + orderId + "]---------");

                    //TODO 6.向微信平台申请支付链接请求
                    logger.info("-------------开始向微信平台申请支付链接---------");

                    //设置当前订单信息
                    HashMap<String, String> mapData = new HashMap<>();
                    mapData.put("body", productNames);  //商品描述
                    mapData.put("out_trade_no", orderId); //使用当前用户订单的编号作为当前支付交易的交易号
                    mapData.put("fee_type", "CNY");//支付币种
                    mapData.put("total_fee", order.getActualAmount() * 100 + "");//支付金额
                    mapData.put("trade_type", "NATIVE"); //交易类型
                    mapData.put("notify_url", "http://47.118.45.73:8080/pay/callback");//设置支付完成时的回调方法接口


                    WXPay wxPay = new WXPay(new PayConfig());
                    Map<String, String> respMap = wxPay.unifiedOrder(mapData);

                    String codeUrl = respMap.get("code_url");

                    logger.info("-------------申请支付链接成功:[" + codeUrl + "]---------");
                    //封装订单处理成功的响应：包含：订单编号，购买的商品名称，支付链接
                    respMap.put("orderId", orderId);
                    respMap.put("productNames", productNames);

                    logger.info("-------------订单处理完成，返回响应:[" + respMap + "]---------");
                    return new ResponseResultVO(RespCode.SUCCESS.getCode(), "success", respMap);
                } else {
                    //库存不足
                    return new ResponseResultVO(RespCode.FAILED.getCode(), "库存不足", null);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                logger.info("-------订单业务操作完成,释放锁:{}-----");
                //业务操作完成后，需要释放掉锁
                for (int i = 0; i < skuIds.length; i++) {

                    // redis的操作是原子性的，但是这里是先查询redis后删除，
                    // 在高并发场景下，可能a线程刚从redis查询完数据(此时锁还没有过期)，此时锁过期了，刚好b线程上了锁
                    // a线程执行删除操作，删除的就是b线程的锁 -> 解决办法：使用lua脚本(保证redis的查询操作与删除操作具有原子性)
                    String skuId = skuIds[i];

                    /*
                    //释放锁时需要判断释放的锁是在业务操作前加的那把锁
                    String s = stringRedisTemplate.boundValueOps(skuId).get();
                    //有可能当前一件商品都没有上锁成功
                    if (StrUtil.isNotBlank(skuId) && s.equals(map.get(skuId))) {
                        stringRedisTemplate.delete(skuId);
                    }
                     */

                    //使用lua脚本进行释放锁
                    List<String> keys = new ArrayList();
                    keys.add(skuId);
                    List rs = (List) stringRedisTemplate.execute(defaultRedisScript, keys, map.get(skuId));

                }
            }
            return new ResponseResultVO(RespCode.FAILED.getCode(), "当前操作出现异常", null);
        } else {

            logger.info("---部分商品上锁失败，开始释放已经上锁的商品:{}----");

            //如果出现部分商品上锁失败，需要释放已经加锁的商品
            for (int i = 0; i < skuIds.length; i++) {
                String skuId = skuIds[i];
                //有可能当前一件商品都没有上锁成功
                if (StrUtil.isNotBlank(skuId)) {
                    stringRedisTemplate.delete(skuId);
                }
            }
            return new ResponseResultVO(RespCode.FAILED.getCode(), "当前订单中，某些商品其他人正在购买，请稍后再试...", null);
        }
    }


    /**
     * 订单处理(使用redisson框架作为分布式锁-解决分布式并发问题)
     *
     * @param cartIds
     * @param order
     * @return
     * @throws Exception
     */
    @Override
    @Transactional //整个为一个事物操作
    public ResponseResultVO addOrderByRedisson(String cartIds, Orders order) throws Exception {

        //参数校验
        if (StrUtil.isEmpty(cartIds) || ObjectUtil.isNull(order)) {
            return new ResponseResultVO(RespCode.FAILED.getCode(), "购物车id或需要添加的订单信息不能为空", null);
        }

        //根据购物车ids查询所有商品信息
        String[] cidArray = cartIds.split(",");
        List<Integer> cidList = new ArrayList<>();
        for (int i = 0; i < cidArray.length; i++) {
            cidList.add(Integer.parseInt(cidArray[i]));
        }
        List<ShoppingCartVO> cartVOList = shoppingCartMapper.listShoppingCartByCartIds(cidList);
        logger.info("-------需要购买购物车商品信息:{}------", cartVOList);


        logger.info("---在多台应用服务器场景下，为防止出现超卖现象，使用redisson上锁，开始上锁----");
        boolean isLock = true;
        String[] skuIds = new String[cartVOList.size()]; //记录已经上锁的商品
        Map<String, RLock> map = new HashMap<String, RLock>();//记录锁
        //一个购物车中可能存在多个商品，需要以每个商品的skuId为key向redis中添加一条记录
        for (int i = 0; i < cartVOList.size(); i++) {
            String skuId = cartVOList.get(i).getSkuId();
            boolean lockResult = false;
            try {
                // 构建锁(获取锁)
                RLock lock = redissonClient.getLock(skuId);
                // 上锁(加锁)-设置加锁等待时间为3s，同时默认超时时间为30s
                lockResult = lock.tryLock(30, TimeUnit.SECONDS);
                //只要商品上锁成功，就记录下来
                if (lockResult) {
                    skuIds[i] = skuId;
                    map.put(skuId, lock);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            isLock = isLock && lockResult; //只要有一件商品没有加锁成功，就表示该笔订单没有加锁成功，需要记录已经上锁的商品
        }


        //响应map
        Map<String, String> respMap = null;
        try {
            if (isLock) {

                logger.info("----当前订单所有商品上锁成功，开始校验库存-------");

                logger.info("----不能马上进行校验库存操作，高并发场景下，可能在查询购物车信息之后，商品加锁之前，其他用户已经修改了库存，此时需要重新查询库存信息-------");

                cartVOList = shoppingCartMapper.listShoppingCartByCartIds(cidList);

                //1.校验库存
                logger.info("-------------开始校验库存---------");

                List<String> productNameList = new ArrayList<>();
                boolean isEnoughStock = true;
                for (ShoppingCartVO cartVO : cartVOList) {
                    if (cartVO.getCartNum() > cartVO.getSkuStock()) {
                        isEnoughStock = false;
                    }
                    productNameList.add(cartVO.getProductName());
                }
                //获取所有商品名称，以,分割拼接成字符串
                String productNames = String.join(",", productNameList);

                if (isEnoughStock) {

                    logger.info("-------------库存校验完成,库存足够。开始生成订单信息---------");

                    //2.保存订单
                    //生成订单编号(简化版uuid)
                    String orderId = IdUtil.simpleUUID();

                    order.setOrderId(orderId);
                    order.setUntitled(productNames);
                    order.setStatus(Constants.OrderStats.NOT_PAYMENT.getValue());
                    order.setCreateTime(new Date());
                    int i = ordersMapper.insert(order);

                    logger.info("-------------订单保存完成。开始生成商品快照---------");

                    //3.生成商品快照
                    for (ShoppingCartVO cv : cartVOList) {
                        String itemId = System.currentTimeMillis() + "" + RandomUtil.randomInt(99999);
                        OrderItem orderItem =
                            new OrderItem(itemId, orderId, cv.getProductId(), cv.getProductName(), cv.getProductImg(), cv.getSkuId(), cv.getSkuName(), cv.getProductPrice(), cv.getCartNum(), new BigDecimal(cv.getSellPrice() * cv.getCartNum()), DateUtil.parse(cv.getCartTime(), "yyyy-MM-dd"),
                                          new Date(),
                                          Constants.CommentStatus.NOT_COMMENT.getValue());

                        int j = orderItemMapper.insert(orderItem);
                        //TODO 增加商品销量，添加时机需要放在用户签收货物后，该笔订单为已完成状态，再增加销量
                    }

                    logger.info("-------------商品快照生成完成。开始扣减库存---------");

                    //4.扣减库存
                    for (ShoppingCartVO sc : cartVOList) {

                        //计算新库存
                        String skuId = sc.getSkuId();
                        int newStock = sc.getSkuStock() - sc.getCartNum();

                        //使用tkmapper提供的方法进行更新:tk会根据传入的id进行部分字段更新
                        ProductSku productSku = new ProductSku();
                        productSku.setSkuId(skuId);
                        productSku.setStock(newStock);

                        int k = productSkuMapper.updateByPrimaryKeySelective(productSku);
                    }
                    logger.info("-------------扣减库存完成。开始删除购物车信息---------");

                    /*
                    //5.删除购物车：当购物车中的记录购买成功之后，购物车中对应做删除操作
                    for (Integer integer : cidList) {
                        //根据id删除购物车信息
                        shoppingCartMapper.deleteByPrimaryKey(integer);
                    }
                    logger.info("-------------删除购物车信息完成。---------");

                    logger.info("-------------订单处理完成。生成订单编号：[" + orderId + "]---------");

                    //TODO 6.向微信平台申请支付链接请求
                    logger.info("-------------开始向微信平台申请支付链接---------");

                    //设置当前订单信息
                    HashMap<String, String> mapData = new HashMap<>();
                    mapData.put("body", productNames);  //商品描述
                    mapData.put("out_trade_no", orderId); //使用当前用户订单的编号作为当前支付交易的交易号
                    mapData.put("fee_type", "CNY");//支付币种
                    mapData.put("total_fee", order.getActualAmount() * 100 + "");//支付金额
                    mapData.put("trade_type", "NATIVE"); //交易类型
                    mapData.put("notify_url", "http://47.118.45.73:8080/pay/callback");//设置支付完成时的回调方法接口


                    WXPay wxPay = new WXPay(new PayConfig());
                    respMap = wxPay.unifiedOrder(mapData);

                    String codeUrl = respMap.get("code_url");

                    logger.info("-------------申请支付链接成功:[" + codeUrl + "]---------");

                     */
                    //封装订单处理成功的响应：包含：订单编号，购买的商品名称，支付链接
                    respMap = new HashMap();
                    respMap.put("orderId", orderId);
                    respMap.put("productNames", productNames);

                }

                logger.info("-------------返回响应(respMap有值代表库存足够，没有值代表库存不足):[" + respMap + "]---------");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            logger.info("-------订单业务操作完成,释放锁:{}-----");
            //业务操作完成后，需要释放掉锁
            for (int i = 0; i < skuIds.length; i++) {

                // redis的操作是原子性的，但是这里是先查询redis后删除，
                // 在高并发场景下，可能a线程刚从redis查询完数据(此时锁还没有过期)，此时锁过期了，刚好b线程上了锁
                // a线程执行删除操作，删除的就是b线程的锁 -> 解决办法：使用redisson分布式锁解决

                String skuId = skuIds[i];
                //有可能当前一件商品都没有上锁成功
                if (StrUtil.isNotBlank(skuId)) {
                    map.get(skuId).unlock();
                }
            }
        }
        return new ResponseResultVO(RespCode.SUCCESS.getCode(), "success", respMap);
    }


    /**
     * 关闭订单
     *
     * @param orderId 订单id
     */
    // tips1：订单表与商品sku表的操作属于一个事物，可以将两个操作抽取到一个方法中，加上spring的事物注解
    @Override
    @Transactional(isolation = Isolation.SERIALIZABLE) //使用spring提供的事物串行隔离级别，解决并发访问库存量的问题
    public void closeOrder(String orderId) {

        // c.情况3：此时有两个用户都在购买同一商品，刚好都订单超时需要回滚库存，需要操作同一变量，就会有并发问题
        //   解决办法1：使用spring的隔离级别为串行，让其一个一个进行执行
        //   解决办法2：使用jvm提供的synchronized加锁，只有持有锁的线程才能进行回滚库存

        synchronized (this) {
            //1.关闭订单表，设置订单状态为 6-已关闭，同时设置关闭类型为 1-超时未支付
            logger.info("---------开始设置订单表状态为：已关闭，且关闭类型为超时关闭------");

            Orders closeOrder = new Orders();
            closeOrder.setOrderId(orderId);
            closeOrder.setStatus(Constants.OrderStats.CLOSED.getValue()); //已关闭
            closeOrder.setCloseType(Constants.OrderCloseStatus.TIMEOUT_NOTPAY.getValue());//超时关闭
            ordersMapper.updateByPrimaryKeySelective(closeOrder);

            logger.info("-----------订单表状态修改完成---------");

            //2.获取订单快照表信息，回滚商品sku表库存数量
            //修改库存表：一笔订单可能会有多个订单快照(不同商品)，需要根据每笔快照的skuId还原库存
            logger.info("-----------开始还原库存---------");
            Example example1 = new Example(OrderItem.class);
            Example.Criteria criteria1 = example1.createCriteria();
            criteria1.andEqualTo("orderId", orderId);
            List<OrderItem> orderItems = orderItemMapper.selectByExample(example1);
            for (OrderItem orderItem : orderItems) {
                //还原库存
                ProductSku productSku = productSkuMapper.selectByPrimaryKey(orderItem.getSkuId());
                productSku.setStock(productSku.getStock() + orderItem.getBuyCounts()); //原库存 + 购买数量
                productSkuMapper.updateByPrimaryKeySelective(productSku);

                logger.info("--------商品：" + orderItem.getProductId() + "，库存还原" + orderItem.getBuyCounts() + "件----");
            }

            logger.info("-----------订单编号： " + orderId + "，所有商品库存还原完成---------");

        }
    }


    /**
     * 根据用户id和订单状态查询订单分页信息
     *
     * @param userId
     * @param status
     * @param pageNum
     * @param limit
     * @return
     */
    @Override
    public ResponseResultVO listOrdersByUserIdAndStatus(String userId, String status, int pageNum, int limit) {

        //获取总数
        Example example = new Example(Orders.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("userId", userId);
        //如果订单状态不为空，也需要作为筛选条件
        if (StrUtil.isNotBlank(status)) {
            criteria.andEqualTo("status", status);
        }

        int count = ordersMapper.selectCountByExample(example);

        //获取页数:如果不能够按照指定的条数分完，则还需要单独加一页
        int pageCount = count % limit == 0 ? count / limit : count / limit + 1;

        //计算起始条数
        int start = (pageNum - 1) * limit;

        //根据关键词查询商品信息
        List<OrdersVO> orders = ordersMapper.selectOrderByUserIdAndStatus(userId, status, start, limit);

        //封装分页对象
        PageHelper<OrdersVO> pageHelper = new PageHelper<>();
        pageHelper.setCount(count);
        pageHelper.setCurrentPageNum(pageNum);
        pageHelper.setLimit(limit);
        pageHelper.setPageCount(pageCount);
        pageHelper.setList(orders);

        if (CollectionUtil.isEmpty(orders)) {
            return new ResponseResultVO(RespCode.SUCCESS.getCode(), "没有订单信息", null);
        } else {
            return new ResponseResultVO(RespCode.SUCCESS.getCode(), "success", pageHelper);
        }
    }

    /**
     * 查询订单(使用pageHelper分页插件进行分页)
     *
     * @param userId
     * @param status
     * @param pageNum
     * @param limit
     * @return
     */
    @Override
    public ResponseResultVO listOrdersByUserIdAndStatusPage(String userId, String status, int pageNum, int limit) {

        //使用pageHelper进行分页查询
        com.github.pagehelper.PageHelper.startPage(pageNum, limit);

        //获取需要分页的数据
        Example example = new Example(Orders.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("userId", userId);
        //如果订单状态不为空，也需要作为筛选条件
        if (StrUtil.isNotBlank(status)) {
            criteria.andEqualTo("status", status);
        }

        //根据关键词查询商品信息
        List<Orders> ordersList = ordersMapper.selectByExample(example);

        //构造分页对象，获取分页信息(总数/分页数/当前页)
        PageInfo<Orders> pageInfo = new PageInfo<>(ordersList);

        return new ResponseResultVO(RespCode.SUCCESS.getCode(), "success", pageInfo);
    }

    /**
     * 更新订单状态
     *
     * @param orderId
     * @param status
     * @return
     */
    @Override
    public int updateOrderStatus(String orderId, String status) {

        Orders orders = new Orders();
        orders.setOrderId(orderId);
        orders.setStatus(status);

        //根据主键进行部分字段更新
        int updateResult = ordersMapper.updateByPrimaryKeySelective(orders);
        return updateResult;
    }

    /**
     * 根据订单id更新删除状态
     *
     * @param orderId
     * @param deleteStatus
     * @return
     */
    @Override
    public ResponseResultVO updateOrderDeleteStatus(String orderId, Integer deleteStatus) {

        if (StrUtil.isBlank(orderId)) {
            return new ResponseResultVO(RespCode.FAILED.getCode(), "订单id不能为空", null);
        }

        Orders order = new Orders();
        order.setOrderId(orderId);
        order.setDeleteStatus(deleteStatus);

        //根据主键进行部分字段更新
        int updateResult = ordersMapper.updateByPrimaryKeySelective(order);

        if (updateResult > 1) {
            return new ResponseResultVO(RespCode.SUCCESS.getCode(), "success", null);
        } else {
            return new ResponseResultVO(RespCode.FAILED.getCode(), "fail", null);
        }
    }
}
